If you give no options, (the project-file must be given), `gpr2mak.exe'
assumes the flags `-d- -r-' as default.
File: rhide.inf, Node: First steps with RHIDE, Next: Environment variables, Prev: The program GPR2MAK.EXE, Up: Introduction
1.7 First steps with RHIDE
==========================
Here I will give you some instructions for the first steps to get contact
with RHIDE.
* Menu:
* What are these so called projects::
* Creating your first project::
File: rhide.inf, Node: What are these so called projects, Next: Creating your first project, Prev: First steps with RHIDE, Up: First steps with RHIDE
1.7.1 What are these so called projects
---------------------------------------
A project for RHIDE is a file, which contains all the needed information
required to build a program or library from one or more source files. Also
all the other options which belong to the look and feel of your desktop
are stored there.
In general RHIDE creates for each project two files. One for the project
itself (it has the suffix `.gpr') and one for the desktop related things
(it has the suffix `.gdt').
To create a new project either run rhide with a not existing project name
as argument or open within RHIDE a project by selecting a name which is
not existent.
File: rhide.inf, Node: Creating your first project, Prev: What are these so called projects, Up: First steps with RHIDE
1.7.2 Creating your first project
---------------------------------
For the next instructions I will assume, that you want to create a project
for the standard "Hello world" program in the current directory. Create now
the new project by running
rhide hello
and you will see an empty desktop and one window opened, the project
window. This window will show you that there is no file defined for your
project. If the project window is selected, (it has a double frame), then
hit there <Ins> and you will be prompted for adding an item to your
project.
Type in the input line now `hello.c' and hit <ENTER>. Now hit <ESC> to
leave the dialog. You will see now, that the project window contains a
line with `hello.c'.
Now hit <ENTER> on that filename and you will get an empty editor window
named `hello.c' prepended by the current directory. In this editor window
you can type now the program:
#include <stdio.h>
int main()
{
printf("Hello world!\n");
exit(0);
}
Now you can select from the Run-menu the Run entry (or use the hotkey
`Ctrl+F9') and RHIDE will do all the necessary steps to compile, link and
execute the program.
If everything was correct (no typing errors) or some other error, you will
get a message box where RHIDE tells you, that the program exited with an
exit code of 0. (This is the value, which you have specified in your
program above in the `exit(0);' statement) This box you can close with
<ENTER> or <ESC>.
To see the output of the program, you can switch now to the user screen
with `Alt+F5' or from the menu (Windows/User screen). To return back to
RHIDE hit any key.
File: rhide.inf, Node: Environment variables, Prev: First steps with RHIDE, Up: Introduction
1.8 Environment variables
=========================
RHIDE uses many environment variables for it's configuration and behavior.
This includes also some standard variables, which are used by the in RHIDE
linked libraries. These are:
$(LOCALEDIR)
This should point to the directory, where your locale files are
stored. If it is not set, RHIDE tries to get the system default
value, which is for Linux `/usr/share/locale' and for DJGPP
`$(DJDIR)/share/locale'.
$(INFOPATH)
This is a pathlist of directories, where your INFO files are stored.
If not set, RHIDE tries the standard directory, which should for
Linux `/usr/info' and for DJGPP `$(DJDIR)/info'.
$(RHIDEOPT)
This variable can be used, to define global RHIDE commandline
options. The value of this variable is used, as if the contents are
given on commandline before any of the real commandline options.
Which means, they can be overwritten on the commandline.
$(ESCDELAY)
This variable is used *ONLY* in the Linux version, where it defines
the delay after pressing <ESC> to wait for another keypress to
simulate an <Alt> keycode. The value is given in milliseconds and
defaults to 1000.
$(LANGUAGE)
This variable is used to specify the language, in which RHIDE should
communicate with you. The contents of this variable should be the ISO
2-character code of your country.
$(RHIDE_SHARE)
With this variable you can tell RHIDE where it should look at first
for it's configuration files.
* Menu:
* Setting environment variables for RHIDE::
* Where to store the environment file::
File: rhide.inf, Node: Setting environment variables for RHIDE, Next: Where to store the environment file, Prev: Environment variables, Up: Environment variables
1.8.1 Setting environment variables for RHIDE
---------------------------------------------
There are some different ways for setting environment variables for RHIDE.
One of them is to set them like any other environment variable on your
system. But this means that these variables are visible also by all the
other programs.
When using the DJGPP version, you can set them in your `djgpp.env' file
either at the beginning as global variables for any DJGPP program or in a
special section `[RHIDE]' only for RHIDE. Please read the doc about the
format of the `djgpp.env' file for more information.
Derived from the technique used on DJGPP for setting environment variables
which are visible only for DJGPP programs, I have added in RHIDE a similar
thing. RHIDE can read environment variables also from a file called
`rhide.env'.
The syntax of this file is very simple. Each line has one of the following
syntax:
VARIABLE=CONTENTS
Which means, that the environment variable `VARIABLE' should become
the contents `CONTENTS' where `CONTENTS' can be also a variable,
which is expanded at runtime.
.OTHER_ENV_FILE
Such a line (it begins with a dot) tells RHIDE to read in at that
point the file `OTHER_ENV_FILE' as environment file. The name
`OTHER_ENV_FILE' can be also an environment variable, which is
expanded before reading the file.
# comments
A line, which begins with a `#' means, that this line is ignored. It
can be used for you to write there some comments about that file.
!VARIABLE=CONTENTS
This is the same syntax as without the ! at the beginning of the line
but it tells RHIDE to place the variable also in the environmen so
also other programs (called by RHIDE) can see this variable.
RHIDE is very powerful in handling the environment variables. Most of it
is taken from the behavior of GNU make. On this great things depend, that
a variable name can consist also of other variables, which are computed
when the variable should be expanded.
As an example of this, you can take a look on the RHIDE sources in the
`rhide.env' files. There I'm using, for instance, the RHIDE builtin
variable $(RHIDE_OS) to define the libraries, which are linked in RHIDE
depending on the operating system where RHIDE is built.
An other example is distributed with RHIDE in it's binary archives as
`rhide_.env' which is commented and should be in a directory
`.../share/rhide/' where the `...' stand for a different directory on
different OS's. (on DJGPP it is %DJDIR% and on Linux it is /usr/local )
Here is a part of the environment file `rhide.var' in the main RHIDE
source directory (which is included by `rhide.env' with
File: rhide.inf, Node: Where to store the environment file, Prev: Setting environment variables for RHIDE, Up: Environment variables
1.8.2 Where to store the environment file
-----------------------------------------
RHIDE searches some known directories for the file `rhide.env' (and of
course also other there defined included files).
At first it searches for a global file in `/usr/local/share/rhide' (on
Linux) or `$(DJDIR)/share/rhide'. Then it searches in `$(HOME)' and at
last in the current directory.
RHIDE does not only a search, it also loads the file, if it was found in
any of the above mentioned directories. That means, if in all these
directories `rhide.env' exists, it is loaded. This has the effect, that
you can define some global defaults which can be overwritten with a
`rhide.env' in the current or your home directory.
File: rhide.inf, Node: General information about how RHIDE works, Next: Description of the pull-down menus, Prev: Introduction, Up: Top
2. General information about how RHIDE works
********************************************
In this section I will give you some comments about the concept of RHIDE.
RHIDE works with the GNU compilers. As a result of this, most of the
options are fixed and they are mostly also specific only for this
compiler. If I speak about compilers, I mean GCC, which calls the right
compilers for you. (`cpp' for preprocessing your input files, `cc1' for
compiling C programs, `cc1plus' for compiling C++ programs and `as' for
compiling assembler files and so on)
Selecting the right compiler for a specific file is done by RHIDE in the
same way as GCC does it. It looks for the extension of the file and
determines the language of this file.
* Menu:
* Known suffixes::
* Syntax of arguments::
* Running under Windows 95::
* Running under OS/2::
* Running under Windows NT::
* Running under Linux::
* General use of RHIDE::
File: rhide.inf, Node: Known suffixes, Next: Syntax of arguments, Prev: General information about how RHIDE works, Up: General information about how RHIDE works
2.1 Known suffixes
==================
The list of the known suffixes is taken from GCC. Remember the fact, that
GCC and RHIDE check the suffixes in a case sensitive way especially when
running under Windows 95 (*Note Running under Windows 95::).
* Valid suffixes for C source files are
`.c'
Normal C source file
`.i'
C source file, which doesn't need the preprocessor
* Valid suffixes for C++ source files are
`.cc'
`.cpp'
`.cxx'
`.C'
Normal C++ source file
`.ii'
C++ source file, which doesn't need the preprocessor
* Valid suffixes for Objective C source files
`.m'
Normal Objective C source file
* Valid suffixes for Pascal source files
`.p'
`.pas'
Normal Pascal source file
* Valid suffixes for object files
`.o'
Normal object file
`'
any other suffix, which has no predefined meaning
* Valid suffixes for libraries
`.a'
Normal library file
* Valid suffixes for executable files
`.exe'
Normal executable file for MS-DOS
`.'
No suffix means the raw COFF image of an executable file. These
can be handled only by programs, which know about this format.
(DJGPP programs know this)
* Valid suffixes for include files
`.h'
Normal include files
`.hpp'
Some people told me, that this suffix should also be treated as
a valid suffix for header files, so I applied it.
`'
Theoretically there is no restriction for such a suffix, but
RHIDE searches and finds only files with the above suffixes in
the specified directories (*Note Include directories::)
* Valid suffixes for Assembler source files
`.s'
Normal Assembler source file
`.S'
Assembler source file, which must be preprocessed by `cpp'. If
you have such files, there is a problem, when long filenames are
not enabled (default in MS-DOS), because RHIDE converts all
filenames in this situation to lower case. But you can add to
the local options for this item (*Note Local options::) the
commandline argument -X ASSEMBLER-WITH-CPP, to tell `GCC' to
preprocess this file first before assembling it.
* Valid suffixes for Fortran source files
`.f'
`.for'
Normal Fortran source files
`.F'
`.fpp'
Fortran source files which need not to be run through `cpp'.
* Valid suffixes for ADA source files
`.adb'
Normal ADA source file
`.ads'
ADA specs file
* Valid suffixes for NASM
`.nsm'
`.asm'
Normal NASM source files.
File: rhide.inf, Node: Syntax of arguments, Next: Running under Windows 95, Prev: Known suffixes, Up: General information about how RHIDE works
2.2 Syntax of arguments
=======================
In RHIDE you can specify some arguments to other programs. These arguments
must be a space separated list of strings. If you want to have one or more
spaces as part of an argument, you have to enclose the whole argument in
single or double quotes.
File: rhide.inf, Node: Running under Windows 95, Next: Running under OS/2, Prev: Syntax of arguments, Up: General information about how RHIDE works
2.3 Running under Windows 95
============================
With DJGPP 2.01 were many bugs fixed, which caused problems under Windows
95 with the long (and case sensitive) filenames. Now all filenames are
shown in lower case, except they contain characters with different case.
That means, all normal 8+3 DOS filenames, which are normally reported in
Windows 95 in upper cases, are automatically converted to lower case. For
more information about filename conversion look at the libc reference.
If you really need the filenames exactly as they are reported by the OS,
you can use the -C switch (*Note Getting started::).
You can also run more than one instance of RHIDE at once, in several
DOS-boxes, because RHIDE creates and uses its own temp directory every
time it starts to disable conflicts, when running multiple compilers at
the same time. This is done by creating a directory in the directory
pointed at by the environment variables %TMPDIR%, %TEMP% or %TMP%, in that
order, until one of them exists. If none of them exists, the current
directory is assumed. Then RHIDE puts the value of this directory into the
environment variable %TMPDIR%. After leaving RHIDE this directory will be
removed, if it is empty.
File: rhide.inf, Node: Running under OS/2, Next: Running under Windows NT, Prev: Running under Windows 95, Up: General information about how RHIDE works
2.4 Running under OS/2
======================
Because I have no access to OS/2, I cannot say anything about it. But some
people said that they run RHIDE under OS/2 successfully, but there must be
the exclusive mouse access to the DOS window disabled.
File: rhide.inf, Node: Running under Windows NT, Next: Running under Linux, Prev: Running under OS/2, Up: General information about how RHIDE works
2.5 Running under Windows NT
============================
File: rhide.inf, Node: Running under Linux, Next: General use of RHIDE, Prev: Running under Windows NT, Up: General information about how RHIDE works
2.6 Running under Linux
=======================
Since RHIDE is now available also for Linux here some hints. In general
you will get the best results when you have installed RHIDE as a setuid
root program. I know, this might be a security problem but I have tried to
make it as secure as possible. After getting acces to the screen and the
keyboard RHIDE will switch back to your normal rights and does not use
root rights any more. It does not write any data or modify any file on
disk with root rights (except you are running as root of course).
The reason for this is the rudimentary support for fast access to the
screen and the totally hided acces to the keyboard in the Linux kernel.
Additionally when you want to use the dual monitor debugging feature of
RHIDE this is also needed, because RHIDE needs in that case access to the
ports of your monochrome video card.
Running RHIDE under X-Window is not full supported (but it is possible).
There are several reasons for this. The first is, that RHIDE uses in that
case only terminal functions for input and output. That means it depends
completetly on your terminfo database and these are (at least for me) in
some cases totally wrong. You can see this mostly that RHIDE does not
handle correct the keyboard. Other programs which use ncurses know this
also and have there own hardcaded patches but I do not want to do so.
To fix the keyboard conflicts whenrunning in a xterm, I distribute little
modified terminfo file `/usr/local/share/rhide/xterm-rhide' which you can
place in `/usr/lib/terminfo/x' or when you have no root access you can
place it also in `$HOME/.terminfo/x'. And then to use this file simply
set the environment variable to this new terminal with
export TERM=xterm-rhide
before running RHIDE in the xterm.
An other alternative is to run RHIDE in a rxvt terminal but there you have
to set also explicitely the TERM variable, because it is set mostly to
xterm-color.
export TERM=rxvt
File: rhide.inf, Node: General use of RHIDE, Prev: Running under Linux, Up: General information about how RHIDE works
2.7 General use of RHIDE
========================
* Menu:
* Creating a program::
* Creating a library::
* Saving/Loading the options::
File: rhide.inf, Node: Creating a program, Next: Creating a library, Prev: General use of RHIDE, Up: General use of RHIDE
2.7.1 Creating a program
------------------------
For creating a program, RHIDE allows you to define multiple source files
which should be compiled and linked to your final program. This is done by
creating a project. In this project you insert your source files (and not
all the include files).
After a source file (which is inserted in your project) compiled at least
once, RHIDE knows about all dependencies of this file, so this file will
be compiled again only, if one of the include files have changed.
* Menu:
* Creating a program without a project::
File: rhide.inf, Node: Creating a program without a project, Prev: Creating a program, Up: Creating a program
2.7.1.1 Creating a program without a project
............................................
Because of many requests of users I made RHIDE to work also without using
a project. This may be good, if you have a single file, but if your
program should be build from more than one file I suggest you to use a
project.
If you have only one editor window opened, the name of the resulting
program is taken from the name of the source file by removing the suffix
and on DJGPP appending `.exe'.
If you have more than one files opened, I saw no other way for determining
the name of the produced program, than naming it `aout' (on DJGPP
`aout.exe').
File: rhide.inf, Node: Creating a library, Next: Saving/Loading the options, Prev: Creating a program, Up: General use of RHIDE
2.7.2 Creating a library
------------------------
You can also create libraries (a collection of object files, which can be
linked with other programs) with RHIDE. The way for doing this is very
simple. Because RHIDE knows about the meaning of file suffixes, you can
change the name of the main target (*Note Main targetname::) to have a
suffix `.a' and that's all. Now RHIDE will run `ar' instead of linking.
File: rhide.inf, Node: Saving/Loading the options, Prev: Creating a library, Up: General use of RHIDE
2.7.3 Saving/Loading the options
--------------------------------
RHIDE supports two different ways for saving the options which you have
customized.
The first one (which I prefer) is the use of the so called default
project. This is the project `rhide.gpr' and must be located in the same
directory where `rhide.exe' is. To create or modify this default project
change to that directory (normally %DJDIR%/bin) and type there
rhide rhide
Now change any options you want and exit RHIDE. From now on these options
are used for any newly created project or when running RHIDE without a
project.
The second way is to save your options to a project file (*Note Save
options::) or to load them from any existing project file (*Note Load
options::).
File: rhide.inf, Node: Description of the pull-down menus, Next: Detailed description of some parts of RHIDE, Prev: General information about how RHIDE works, Up: Top
3. Description of the pull-down menus
*************************************
This chapter describes the pull-down menus and all their sub-menus. The
main menu bar, the topmost line of the screen, is selected with the hotkey
<F10> or by clicking with the mouse at this line. You can walk through the
menu with the cursor keys and a menu entry is selected with <ENTER> or by
clicking with the mouse on it.
* Menu:
* System menu::
* File::
* Edit::
* Search::
* RUN::
* Compile menu::
* Debug::
* PROJECT::
* Options::
* Windows::
* Help submenu::
File: rhide.inf, Node: System menu, Next: File, Prev: Description of the pull-down menus, Up: Description of the pull-down menus
3.1 System menu
===============
This menu has its name only that one can speak about it. The symbol for
this menu is the leftmost symbol in the menu bar. <Alt+SPACE> selects
this menu.
* Menu:
* About::
* Bug report::
* FSDB::
* GREP::
* GDB::
* Refresh Desktop::
* Calculator::
* Puzzle::
* Calender::
* ASCII table::
File: rhide.inf, Node: About, Next: Bug report, Prev: System menu, Up: System menu
3.1.1 About
-----------
This brings up a window with information about the author and the version
of RHIDE.
File: rhide.inf, Node: Bug report, Next: FSDB, Prev: About, Up: System menu
3.1.2 Bug report
----------------
This menu entry opens an editor with some important information which
should be part of a bug report and where you can describe the problem.
File: rhide.inf, Node: FSDB, Next: GREP, Prev: Bug report, Up: System menu
3.1.3 FSDB
----------
With this menu item you can call the FSDB debugger, which comes with
DJGPP. But remember, this runs the debugger as an external program and it
is not integrated in RHIDE.
File: rhide.inf, Node: GREP, Next: GDB, Prev: FSDB, Up: System menu
3.1.4 GREP
----------
This is a very useful function. You can type the arguments for grep in the
input line, which will be shown, and after this the program grep is
called. The messages from grep are redirected to the message window (*Note
Message window::).
File: rhide.inf, Node: GDB, Next: Refresh Desktop, Prev: GREP, Up: System menu
3.1.5 GDB
---------
This is analog to the call of FSDB (*Note FSDB::).
File: rhide.inf, Node: Refresh Desktop, Next: Calculator, Prev: GDB, Up: System menu
3.1.6 Refresh Desktop
---------------------
This function is sometimes useful, if you had run your program and it
wrote some things to the screen (for redirecting `stdout' and `stderr'
from your program to a window in RHIDE (*Note Preferences::)).
File: rhide.inf, Node: Calculator, Next: Puzzle, Prev: Refresh Desktop, Up: System menu
3.1.7 Calculator
----------------
This brings up a dialog, where you can do some calculations. This dialog
is similar to the evaluate dialog (*Note Evaluate/Modify::), but it uses
not the feature of GDB, but it is a separate calculator. For more
information see *Note Documentation for the editor: (editor)Calculator,
There can be used also some of the standard functions like `log', `sin'
and so on and it can convert also integer values between different bases
(`hex', `oct', `dec').
File: rhide.inf, Node: Puzzle, Next: Calender, Prev: Calculator, Up: System menu
3.1.8 Puzzle
------------
This will open a small window, where you can play a little puzzle game.
The "stones" are moved with the cursor keys or by clicking with the mouse
on it.
File: rhide.inf, Node: Calender, Next: ASCII table, Prev: Puzzle, Up: System menu
3.1.9 Calender
--------------
This will open a little calender. With the cursor keys <Up> and <Down> you
can switch to the next/previous month or click with the mouse on the small
symbols in the upper corners.
File: rhide.inf, Node: ASCII table, Prev: Calender, Up: System menu
3.1.10 ASCII table
------------------
This will open a window with all the ASCII characters. Move around with
the cursor keys or press any key to select any wanted character. In the
bottom line you will see the the character and the value of it (decimal
and hexadecimal). The decimal value can be used to create that character
for instance in the editor by holding the <Alt> key down and typing the
value on the numeric key pad.
File: rhide.inf, Node: File, Next: Edit, Prev: System menu, Up: Description of the pull-down menus
3.2 File
========
In this menu you can find functions, which deal with files, like open,
Here you can set the bound for the fuzzy search. The range is from 1 to
1000 where 1 means that mostly every string matches any other string and
1000 means the exact match.
File: rhide.inf, Node: Index for syntax help, Next: libc reference, Prev: Syntax help submenu, Up: Help submenu
3.11.4 Index for syntax help
----------------------------
Here you can get a list of all available topics for the syntax help, from
where you can choose one (<Enter>, <Space> or double click).
File: rhide.inf, Node: libc reference, Next: Help about help, Prev: Index for syntax help, Up: Help submenu
3.11.5 libc reference
---------------------
This is a separate menu entry to open the libc reference, because this is
used very often when writing C programs.
File: rhide.inf, Node: Help about help, Prev: libc reference, Up: Help submenu
3.11.6 Help about help
----------------------
This brings up a help-window for instructions and available keystrokes
when using the integrated INFO viewer. (see *Note Top: ()Top,)
File: rhide.inf, Node: Detailed description of some parts of RHIDE, Next: Debugging with RHIDE, Prev: Description of the pull-down menus, Up: Top
4. Detailed description of some parts of RHIDE
**********************************************
* Menu:
* Selecting a window::
* How the editor works::
* Some hints and problems::
* Project window::
* Builtin compiler specs::
* Builtin variables::
* Change the defaults of RHIDE::
* Message window::
* Syntax highlighting::
* Checking the dependencies::
* What is Turbo Vision::
* How the dialogs work::
* Defining macros::
* The INFO Viewer::
* RCS and RHIDE::
File: rhide.inf, Node: Selecting a window, Next: How the editor works, Prev: Detailed description of some parts of RHIDE, Up: Detailed description of some parts of RHIDE
4.1 Selecting a window
======================
To select a window you can do the following. If the window has a number,
this is right on the top-frame, you can select this window by pressing
<Alt> and this number (but only if the number is a single digit). Or you
click anywhere in the window or on the frame of the window with your mouse.
File: rhide.inf, Node: How the editor works, Next: Some hints and problems, Prev: Selecting a window, Up: Detailed description of some parts of RHIDE
4.2 How the editor works
========================
This section should describe the work of the editor. But because the editor
is now so complex and, not my own work, there is now separate
documentation, see *Note Documentation for the editor: (editor)Top, for a
detailed and better doc. But you can read also more from my doc, which
describes the most common (for me) usage of the editor.
Here I describe most of the editor commands. If there is a key command like
`Ctrl+Q+Y', press <Ctrl> and <Q> simultaneously and after this press <Y>.
I strongly recommend not to use the technique by holding down the <Ctrl>
key when pressing the second key in such key combinations, because for
instance when you press `Ctrl+K' and then `Ctrl+C' you will be prompted if
you want to interrupt RHIDE (because you pressed the interrupt key). But
if you really want to use this methode, you should use the `-C'
commandline switch when starting RHIDE to disable the handling of
`SIGINIT'.
* Menu:
* Erasing commands::
* Cursor moving commands::
* Text selecting and searching commands::
* Block commands::
* Other commands::
File: rhide.inf, Node: Erasing commands, Next: Cursor moving commands, Prev: How the editor works, Up: How the editor works
4.2.1 Erasing commands
----------------------
* <Ctrl+G> or <Del> erases the character under the cursor or the
selected text.
* <Ctrl+H> or <Backspace> erases the character before the cursor or the
selected text.
* <Ctrl+Y> erases the current line.
* <Ctrl+Q+Y> erases from the cursor to the end of the line.
* <Ctrl+Q+H> erases from the cursor to the beginning of the line.
* <Ctrl+T> erases from the cursor to the beginning of the next word on
this line.
* <Ctrl+Backspace> erases from the cursor to the beginning of the
previous word.
File: rhide.inf, Node: Cursor moving commands, Next: Text selecting and searching commands, Prev: Erasing commands, Up: How the editor works
4.2.2 Cursor moving commands
----------------------------
* <Ctrl+S> or <Arrow left> moves the cursor one character left.
* <Ctrl+D> or <Arrow right> moves the cursor one character right.
* <Ctrl+E> or <Arrow up> moves the cursor one line up.
* <Ctrl+X> or <Arrow down> moves the cursor one line down.
* <Ctrl+A> moves the cursor one word left.
* <Ctrl+F> moves the cursor one word right.
* <Ctrl+C> or <Page down> moves the cursor one page down.
* <Ctrl+R> or <Page up> moves the cursor one page up.
* <Ctrl+Q+D> or <End> moves the cursor to the end of the line.
* <Ctrl+Q+S> or <Home> moves the cursor to the beginning of the line.
* <Ctrl+Q+R> or <Ctrl+PgUp> or `Ctrl+Home' moves the cursor to the
beginning of the file.
* <Ctrl+Q+C> or <Ctrl+PgDown> or `Ctrl+End' moves the cursor to the end
of the file.
File: rhide.inf, Node: Text selecting and searching commands, Next: Block commands, Prev: Cursor moving commands, Up: How the editor works
4.2.3 Text selecting and searching commands
-------------------------------------------
* <Shift> cursor keys select the text as the cursor moves.
* <Ctrl+Ins> or <Ctrl+K+K> copy the selected text to the clipboard.
* <Shift+Del> or <Ctrl+K+Y> move the selected text to the clipboard.
* <Shift+Ins> or <Ctrl+K+C> copy the selected text from the clipboard
to the current cursor position.
* <Ctrl+Del> delete the selected text.
* <Ctrl+Q+A> open the replace dialog.
* <Ctrl+Q+F> open the find dialog.
* <Ctrl+L> repeat the last replace or find operation.
* <Ctrl+K+H> unselect all.
File: rhide.inf, Node: Block commands, Next: Other commands, Prev: Text selecting and searching commands, Up: How the editor works
4.2.4 Block commands
--------------------
* <Ctrl+K+B> sets the start of the selected block.
* <Ctrl+K+K> sets the end of the selected block.
* <Ctrl+K+I> indents the selected block by inserting a space at the
beginning of each line inside the block.
* <Ctrl+K+U> unindents the selected block by erasing one character from
the beginning of each line inside the block, which starts with a tab
or space.
* <Ctrl+K+M> converts all alpha characters inside the selected block to
upper case.
* <Ctrl+K+O> converts all alpha characters inside the selected block to
lower case.
* <Ctrl+K+V> moves the selected block to the current cursor position.
* <Ctrl+K+Tab> indents the selected block by using the last non
selected line as reference for indenting.
* <Ctrl+K+Shift+Tab> unindents the selected block by using the last
non-selected line as reference for unindenting.
* <Ctrl+K+R> inserts the contents of a file at the current cursor
position.
* <Ctrl+K+W> writes the selected block to a file.
File: rhide.inf, Node: Other commands, Prev: Block commands, Up: How the editor works
4.2.5 Other commands
--------------------
* <Ctrl+V> Toggle insert-/overwrite-mode.
* <Ctrl+O> Toggle auto-indent-mode on/off.
* <Ctrl+J> Goto line ... (Will be prompted for.)
* <Ctrl+K+?> ?, a digit (<0> - <9>). Set a marker in the text (up to
ten different markers).
* <Ctrl+Q+?> ?, a digit (<0> - <9>). Jump to a marker, which you have
previously set.
* <Shift+Space> Executes a macro, which can be defined externally by
analyzing the last two characters before the cursor. (*Note Defining
macros::)
If you have set some markers, they will be stored, so you can use them
later when restarting RHIDE.
File: rhide.inf, Node: Some hints and problems, Next: Project window, Prev: How the editor works, Up: Detailed description of some parts of RHIDE
4.3 Some hints and problems
===========================
To compile only a single file, you don't need to include it in a project.
You only have to open it and do a compile. If a file is in your project,
you can compile it, if you are in its editor-window or if you are in the
project-window and this file is selected.
Warnings and errors from compiling a file are listed in the message-window.
If there are warnings or errors, you can jump to the corresponding source
by hitting <ENTER> on this message. If this file wasn't already opened, it
will be opened.
* Menu:
* Problems with automatic dependencies::
File: rhide.inf, Node: Problems with automatic dependencies, Prev: Some hints and problems, Up: Some hints and problems
4.3.1 Problems with automatic dependencies
------------------------------------------
Most checking of the dependencies works correctly, but there are some few
situations, where this checking gets confused. The first results in the
fact that I implemented a cache function for getting the modification time
of files, that means, most files are 'stat'ed only once, after starting
RHIDE. But if someone modifies one of the files, which are in the cache,
(this can be another program, when you run RHIDE in a multitasking
environment, such as Windows) or if you run your project and it modifies
some of these files, the internal cache is after this not up to date.
Here is another situation. Your source files are not in the current
directory. You have opened a source file for editing and successfully
built your project. Now you leave RHIDE, because you want to debug your
program with `FSDB', you copy the source file (in this case it is the
file, which you have opened in the IDE) to the current directory. Now you
debug it and there are some errors. You restart RHIDE to make the changes
in the file. The previously opened file will be opened automatically and
you edit it. If you do now a *Make*, RHIDE tells you, that your project is
up to date, because it searches for source files at first in the current
directory, and there is the unmodified file.
In this chapter I will give you for some special parts a more detailed
description of what they do.
File: rhide.inf, Node: Project window, Next: Builtin compiler specs, Prev: Some hints and problems, Up: Detailed description of some parts of RHIDE
4.4 Project window
==================
The project window shows you every file, which you have included in your
project. Most time you work with RHIDE this window should be visible, but
you can also close it (*Note Close::).
* Menu:
* Items of your project::
* Open a project item::
* Dependencies of project item::
* Local options for a project item::
File: rhide.inf, Node: Items of your project, Next: Open a project item, Prev: Project window, Up: Project window
4.4.1 Items of your project
---------------------------
The items in the project window, and therefore also in your project, are
sorted in alphabetical order. This has the effect of faster finding an
item and you can also move the selecting bar to a specified item by typing
the name of this item.
Normally, the alphabetic order of the project items causes no problems
because the linker searches at first *every* object file for unresolved
symbols before any library. The statement, the the GNU linker is a one pass
linker makes sense only for libraries, because they are checked only once
for unresolved references. That means, if you include libraries in your
project you must know about the order, where this library is put on the
command line when linking your program.
If you have problems with that order, or if you really want to have one
object file (or library) before some others, you must rename them, to get
the right position from the name.
File: rhide.inf, Node: Open a project item, Next: Dependencies of project item, Prev: Items of your project, Up: Project window
4.4.2 Open a project item
-------------------------
To open an editor window with the selected item press either <ENTER> or
<SPACE>. If there was already a window with this file opened on the
desktop, this window will be selected. This works only if the selected
item has a known suffix (*Note Known suffixes::). If the selected item is
a project file, that project will be opened with the side effect that if
you close this project, the previous one will be reopened.
File: rhide.inf, Node: Dependencies of project item, Next: Local options for a project item, Prev: Open a project item, Up: Project window
4.4.3 Dependencies of project item
----------------------------------
If you have compiled a file already in RHIDE, you bring up a list with all
dependencies of that file. In this list the files are show by their
basename followed by the directory and they are also sorted in alphabetical
order. From here you can also open an editor window with the selected
dependency by pressing <SPACE> or <ENTER> on that item.
File: rhide.inf, Node: Local options for a project item, Prev: Dependencies of project item, Up: Project window
4.4.4 Local options for a project item
--------------------------------------
You can change many options for a project item, which are in effect only
for this file. To do this, hit <Ctrl+O> on the selected item and a dialog
is shown, where you can change the options.
At this time you can change the following options.
* Menu:
* Local commandline options::
* exclude from link::
* rebuild seldom::
* Name of the output file::
* Compiler type::
* User defined compiler::
* Error checking::
* Error program::
File: rhide.inf, Node: Local commandline options, Next: exclude from link, Prev: Local options for a project item, Up: Local options for a project item
Local commandline options
.........................
Here you can give some additional defines or any other commandline
options, when compiling this item.
File: rhide.inf, Node: exclude from link, Next: rebuild seldom, Prev: Local commandline options, Up: Local options for a project item
exclude from link
.................
This is a switch to tell RHIDE, that this file should not be linked with
your program, but it is compiled and it is checked to determine if your
program is up to date.
File: rhide.inf, Node: rebuild seldom, Next: Name of the output file, Prev: exclude from link, Up: Local options for a project item
rebuild seldom
..............
When you select this option the item is compiled only if it does not
already exist. For most project items this is not usefull but if you have
included in your project other projects which create a library this might
be usefull, especially if the library has many source files and you know,
that they change very seldom.
File: rhide.inf, Node: Name of the output file, Next: Compiler type, Prev: rebuild seldom, Up: Local options for a project item
Name of the output file
.......................
Here you can specify another name as the compiled file. Put here only the
basename of the file (without any directory)
File: rhide.inf, Node: Compiler type, Next: User defined compiler, Prev: Name of the output file, Up: Local options for a project item
Compiler type
.............
From that list you can select exactly one type of the compiler, which is
used to create your output file. Possible values are:
`Auto'
This is the default and should be used in most cases. When this type
is selected, RHIDE selects the correct compiler depending on the
suffixes of your source and output file.
`User'
If you have any special compiler, which is not known to RHIDE, to
create your output file, you must select this and give RHIDE also the
calling syntax of that compiler (see below)
`None'
If you don't want to compile this item select this.
`GNU C compiler'
Tell RHIDE to compile this file like a normal GNU C source file.
`GNU C++ compiler'
Tell RHIDE to compile this file like a normal GNU C++ source file.
`GNU assembler'
Tell RHIDE to compile this file like a normal GNU assembler file.
`GNU Pascal compiler'
Tell RHIDE to compile this file like a normal GNU Pascal file.
File: rhide.inf, Node: User defined compiler, Next: Error checking, Prev: Compiler type, Up: Local options for a project item
User defined compiler
.....................
If you have selected the User compiler type, you have to put in the next
input line the specs on how to call the compiler. These specs can use any
variables that are known to RHIDE (*Note Builtin variables::) together
with normal text. As an example I show here, how the builtin C compiler is
defined (the backslashes at the end of the lines are used only here to
show, that the line is continued, they are NOT part of the specs):
File: rhide.inf, Node: Error checking, Next: Error program, Prev: User defined compiler, Up: Local options for a project item
Error checking
..............
Here you can select how errors or warnings that are produced by the
compiler, are checked. Possible values are:
`Auto'
Let RHIDE select the correct way for checking the errors
`User'
Use your own external program to check the output of the compiler to
`stderr'
`None'
Do not check any errors, assume that the compiler does it's job every
time successfully.
`builtin C'
Check the errors like when compiling a C file
`builtin assembler'
Check the errors like when compiling an assembler file
`builtin linker'
Check the errors like when linking
`return value'
Determine only if the compiling was successful or not by checking the
return value of the compiler (zero for success)
File: rhide.inf, Node: Error program, Prev: Error checking, Up: Local options for a project item
Error program
.............
If you have selected above the User error checking, type here the program,
which should check for errors and/or warnings. What the external error
checking program should do:
- The program must take a filename as argument, which contain the
output to stderr from the compiler (Error and warning messages)
- The program has to write to stdout the Warnings, Errors or messages
in a special format.
`Errors'
A line that starts with the string "!Error" (without the double
quotes) optionally followed by "!File" and a filename in single
quotes and "!Line" followed by a space and a line number and
"!Column" followed by a space and a coloumn number.
If "!Line" and/or "!Column" are not used they dafault to 0. The
next line contain the error text. Example:
!Error!File'test.c'!line17
This is a sample error message
This means, that in file 'test.c' at line 17 an error occurred
with the description 'This is a sample error message'
`Warnings'
Warnings have the same format, except that !Error is replaced by
!Warning.
`Any other line'
is treated as a simple message optionally preceeded by !File and
!Line.
File: rhide.inf, Node: Builtin compiler specs, Next: Builtin variables, Prev: Project window, Up: Detailed description of some parts of RHIDE
4.5 Builtin compiler specs
==========================
WARNING: THE LIST OF VARIABLES AND STRINGFUNCTIONS DESCRIBED BELOW MIGHT
NOT BE UPTODATE. IF YOU WANT TO GET INFORMATION ABOUT ALL FEATURES PLEASE
LOOK IN THE SOURCES FOR RHIDE.
RHIDE uses for compiling, linking, and the other stages of generating a
file also specs, like you can change in the local options for a project
item (*Note Local options::). Here the specs, which are used currently:
$(RHIDE_COMPILE_C)
For compiling C source files
$(RHIDE_COMPILE_CC)
For compiling C++ source files
$(RHIDE_COMPILE_ASM)
For compiling assembler source files
$(RHIDE_COMPILE_PASCAL)
For compiling Pascal source files
$(RHIDE_COMPILE_OBJC)
For compiling objective C source files
$(RHIDE_COMPILE_LINK)
For linking
$(RHIDE_COMPILE_LINK_PASCAL)
For linking when the project contain Pascal source files
$(RHIDE_COMPILE_LINK_PASCAL_AUTOMAKE)
This spec is used only, when you have set the (*Note Primary file::),
to tell RHIDE, not to check for dependencies but to use the 'automake'
feature of GPC.
$(RHIDE_COMPILE_ARCHIVE)
For creating a library
$(RHIDE_FSDB)
For calling FSDB.
$(RHIDE_GDB)
For calling GDB.
$(RHIDE_GPROF)
For calling GPROF.
$(RHIDE_GREP)
For calling grep.
All of these specs have a default content in RHIDE, but they can be
overwritten by setting the environment variable with the same name and any
other contents.
File: rhide.inf, Node: Builtin variables, Next: Change the defaults of RHIDE, Prev: Builtin compiler specs, Up: Detailed description of some parts of RHIDE
4.6 Builtin variables
=====================
This section describes, which variables can be used within RHIDE to get
values from some of the configurations, which you have made inside RHIDE.
All of these variables are referenced by a name enclosed in parentheses
preceeded by a dollar sign. Example: `$(RHIDE_GCC)'. You can overwrite any
of the following variables, if you define in your environment the same
variable with any contents you want.
When RHIDE tries to get the contents of such a variable, it searches at
first if it is found in it's internal database. If it was not found, the
environment is checked for such a variable and if that fails, the
resulting value is the variable itself.
In addition to the use of variables, RHIDE has a limited ability of using
string manipulating functions. I have implemented some of the functions,
which are available with GNU make. They have the same name and should work
exactly like the GNU make counterpart.
`$(strip arg)'
This function removes any leading and trailing whitespace and converts
all multispaces to single spaces from the (whitespace separated list)
`arg'.
`$(addsuffix arg1,arg2)'
These functions append on each argument from the whitespace separated
list `arg2' the string `arg1'.
`$(addprefix arg1,arg2)'
This is the same as `$(addsuffix arg1,arg2)', except that it puts the
string `arg1' before each argument from `arg2'.
`$(notdir arg)'
This removes any directory part from the argument `arg'.
`$(dir)'
This extracts only the directory part from the argument `arg'. If
there was no directory in `arg', an empty string is returned. (The
directory contains also the drive letter, if there was one)
`$(subst arg1,arg2,arg3)'
This replaces every occurrence of `arg1' in `arg3' with `arg2'
The following variables have a special meaning in RHIDE with the default
The following are not used as real variables, but they are used to get the
contents of options from RHIDE. But you can override them also by setting
them as an environment variable.
$(INCLUDE_DIRS)
All the include directories
$(LIB_DIRS)
All the library directories
$(SOURCE_NAME)
The actual compiled source file
$(OUTFILE)
The actual created file
$(C_DEBUG_FLAGS)
All the debugging flags
$(C_OPT_FLAGS)
All the optimization flags
$(C_WARN_FLAGS)
All the warning flags
$(C_C_LANG_FLAGS)
All the C language flags
$(C_CXX_LANG_FLAGS)
All the C++ language flags
$(C_P_LANG_FLAGS)
All the Pascal language flags
$(LIBS)
All the libraries, which are given in the libraries options
$(LD_EXTRA_FLAGS)
All the additional linker options
$(LOCAL_OPT)
All the local options for that project item
$(OBJFILES)
All the destination files, which are part of the project and which
are not a library and not excluded from linking
$(LIBRARIES)
All the libraries, which are explicitly included in the project and
not excluded from linking
$(SPECIAL_CFLAGS)
Some special flags for `GCC'. Currently only the `-nostdlib' switch.
$(SPECIAL_LDFLAGS)
Some special flags for `GCC' when linking. Currently only the
switches `-pg' and `-nostdlib'.
$(prompt TITLE)
RHIDE prompts for arguments which get the title `TITLE' and insert
the parameters here.
File: rhide.inf, Node: Change the defaults of RHIDE, Next: Message window, Prev: Builtin variables, Up: Detailed description of some parts of RHIDE
4.7 Change the defaults of RHIDE
================================
If you have special wishes for compiling your source files, you can
configure for RHIDE mostly everything. For adding support for other than
the builtin known file types (*Note Builtin variables::). If you want to
change the behavior of RHIDE for compiling all the known file types you
should know at first really what you do. If you think, this is a good idea
or if you only want only check if it works you can do it.
Before RHIDE compiles any file (this includes also linking and building a
library) it searches the environment for a variable after the following
scheme: When compiling a file with suffix `.c' to a file with suffix `.o'
RHIDE checks for the variable $(RHIDE_COMPILE.c.o). If this variable is
defined the contents of this variable is taken as the compile spec.
If you want to change the specs for linking you must take as destination
suffix `.exe' or `.' and as source suffix the suffix of your object files.
Example:
$(RHIDE_COMPILE.o.)
File: rhide.inf, Node: Message window, Next: Syntax highlighting, Prev: Change the defaults of RHIDE, Up: Detailed description of some parts of RHIDE
4.8 Message window
==================
This window shows every time you compile a file the resulting messages,
which GCC produces. These messages were converted in a special format to
show them in the window. Some of the messages contain a file eventually
combined with a line number. If you press <ENTER> on such a message, the
corresponding source line in the file will be highlighted and the window
with this file will be selected. If this file is not already on the
desktop, it will be opened.
If the file, to which the messages refer, is already in the foreground you
can see the selected source line for your messages directly on the screen.
File: rhide.inf, Node: Syntax highlighting, Next: Checking the dependencies, Prev: Message window, Up: Detailed description of some parts of RHIDE
4.9 Syntax highlighting
=======================
Syntax highlighting is now supported directly by the editor. It should
work in mostly every situation for all the supported types. Currently (in
RHIDE) only the C/C++ style syntax highlight and the Pascal style syntax
highlight are supported.
With which style a file is highlighted is chosen by RHIDE by checking the
suffix of the file and determining the file type from that suffix. (*Note
Known suffixes::)
File: rhide.inf, Node: Checking the dependencies, Next: What is Turbo Vision, Prev: Syntax highlighting, Up: Detailed description of some parts of RHIDE
4.10 Checking the dependencies
==============================
This is one of the main parts of RHIDE. To speed up the work, I have added
a cache for checking the modification time of a file and for finding a
file (computing the full name of a file). But sometimes the data in the
cache isn't valid, especially when running under Windows. If you see this,
you can clear the cache by leaving RHIDE and starting again.
If you didn't do any special things but have problems with it, please run
RHIDE with the `-df' switch and try to find out, where the problem is and
post it to me so I can fix it.
File: rhide.inf, Node: What is Turbo Vision, Next: How the dialogs work, Prev: Checking the dependencies, Up: Detailed description of some parts of RHIDE
4.11 What is Turbo Vision
=========================
The Turbo Vision library is part of Turbo C++ version 3.1. I have ported
this library to use with DJGPP because I think it is the most powerful
text windowing library, which is available for MS-DOS. With the help of
this library you can write a front end application which looks very well
and has an interface that is easy to use.
The Turbo Vision library is not only a window based text user interface,
it is also a very good event handling mechanism. It supports the use of
the mouse and keyboard with the ability of defining and using of hotkeys.
That means, you can assign to some key or combinations of keys, which
function should be executed.
The main parts of an application, which is using this library, are the
desktop, the menu bar and the status line. The menu bar is usually shown
as the topmost line of the screen. There are shown the main parts of the
pull down menus, from where you can select the most functions, which are
implemented in an application.
To use the menu you can use the mouse as well the keyboard. With the mouse
you can click every where on a menu entry and the corresponding function
will be executed. There are some different actions, which a menu entry can
have. At first some of them, these are, for example, all the entries in the
menu bar, open a submenu with more menu entries which are related to the
name of this main entry. And the others, most in such a submenu, execute a
definite function of the application.
With the keyboard you can walk through the menu very simply. Press <F10>
to activate the menu bar. In the pull down menus you can use the cursor
keys to move the highlighted bar up and down and with the cursor right and
left keys you can switch to next or previous menu. With the <ENTER> key
you activate the function, which corresponds to this entry. If this was a
submenu, which is indicated with a symbol like a small right arrow, this
will be opened.
If you walk through the menu with the cursor keys or the mouse (hold the
left mouse button down and move the mouse) in the status line will be
shown for each entry a short hint for the function of this menu entry.
File: rhide.inf, Node: How the dialogs work, Next: Defining macros, Prev: What is Turbo Vision, Up: Detailed description of some parts of RHIDE
4.12 How the dialogs work
=========================
In a dialog, like the file open dialog, are many things which you can
select or where you can type in some data. At first some general
functions. If you press <ESC> the dialog will be closed and nothing will
be changed. The same can be done with the mouse by clicking on the close
symbol (this is the small symbol on upper left frame of the dialog).
In the next paragraphs I will describe the most used elements of a dialog.
For selecting each element of a dialog you can use the <Tab> key to select
the next element in the dialog or the `Shift+Tab' key, to select the
previous element.
A button is a rectangle with some text on it. If you activate such a
button a specified action is executed. To select a button you can use the
<Tab> key, until the button is specially highlighted and press <ENTER>
then. Most times a character of the text on this button has a different
color. So you can press <Alt> plus this character to activate the button.
With the mouse you can simply click on a button to activate it.
A Listbox is a collection of some strings in one or more columns and rows
as needed. The project window (*Note Project window::) is such a Listbox
with the names of the project items. You can use the cursor keys to move
the focus bar in the list, or if it is a sorted Listbox, you can also type
some characters and the focus will move to the item, which starts with
these characters. To select a item in a list box, press <SPACE> or <ENTER>
or double click with mouse on it.
In an input line you can type some text which can be edited with the usual
editing keys.
A checkbox is a collection of options, which can be turned on or off.
Each option has in front of it a small indicator, if it is turned on (an X
is shown) or not (the X is not shown). To toggle such an option, use the
cursor keys to move the focus to the option you want and press <SPACE> or,
if a character in an option string is highlighted you can press this key
and the option will be turned on or off or click with the mouse on the
option.
Radiobuttons are similar to Checkboxes, but there you can select only one
of all the shown options.
File: rhide.inf, Node: Defining macros, Next: The INFO Viewer, Prev: How the dialogs work, Up: Detailed description of some parts of RHIDE
4.13 Defining macros
====================
Please look for a detailed documentation here: see *Note Documentation
about Pseudo Macros: (editor)Pseudo Macros,
File: rhide.inf, Node: The INFO Viewer, Next: RCS and RHIDE, Prev: Defining macros, Up: Detailed description of some parts of RHIDE
4.14 The INFO Viewer
====================
The integrated help system of RHIDE is based on the INFO Viewer written by
SALVADOR EDUARDO TROPEA (SET) <ice@inti.edu.ar>. It gives you access to
all the INFO files which you have installed in the correct directories as
is done for `info.exe'.
To get help about the INFO Viewer hit <F1> when the help-window is opened
or follow this link to see *Note Top: (infview)Top.
In addition to getting help with this system you can also copy text from
the help screen to the clipboard. This is useful if you want for instance
to copy an example from the libc reference in your program. This feature
is not so powerful as in the editor, but it is good enough. To mark some
text use the <Shift> and cursor keys and copy the selected text with
`Ctrl+Ins' to the clipboard.
In RHIDE you have also the possibility to get help about a specific
function. Currently this works only for functions, which are documented in
the libc reference. For doing this, move the cursor to the function and
hit <Ctrl+F1> or click with the right button of the mouse on that word.
File: rhide.inf, Node: RCS and RHIDE, Prev: The INFO Viewer, Up: Detailed description of some parts of RHIDE
4.15 RCS and RHIDE
==================
RHIDE knows a little bit about RCS, the Revision Control System. Since RCS
is available also for DJGPP I enabled now some features to use RHIDE also
on packages which use RCS.
RHIDE can handle RCS files in the way, that it searches for a checked in
source file if the normal source file was not found. The complicatest part
here was to determin the correct RCS file name from the source name.
(Especially under DJGPP this is a problem since under raw DOS it is not
possible to use names like 'foo.c,v').
So I decided to use the external program `rlog' which comes with the RCS
package to determine the actual correct RCS source name. I did so because
the DJGPP implementation knows enough about the DOS limitation and how to
solve them.
This help here is not ment to be a RCS introduction. If you don't know
what RCS is or what can be done with it, please look in the manuals wich
come with RCS.
Here now what RHIDE knows about the RCS files. If a source file was not
found, it's RCS name is computed with the spec `$(RHIDE_RLOG)' which
defaults to `$(shell rlog -R $(rlog_arg))' where `$(rlog_arg)' is
substituted at runtime with the actual wanted source file.
This spec can be overwritten to speed it up. An example for this can be
found in the distributed sample environment file `rhide_.env'.
When RHIDE only wants to compile the file or only to get the modification
time it is temporary checked out (without locking it) and after the needed
operation (compiling) it is removed (for checking the modification time it
is not checked out, but the time form the RCS file is taken).
If you want to open that file for editing the same is done but now it is
checked out with setting a lock and it is not checked in after closing the
window. The spec for checking the file out is `$(RHIDE_CO)' which can be
overwritten also and it defaults to `$(shell co -q $(co_arg))' where the
switch `-l' is added when it is checked out for edititing otherwise
`$(co_arg)' is substituted at runtime only with the wanted source file.
File: rhide.inf, Node: Debugging with RHIDE, Next: Debugging with RHGDB, Prev: Detailed description of some parts of RHIDE, Up: Top
5. Debugging with RHIDE
***********************
For debugging your programs you need now no external debugger, because
RHIDE has one integrated. The integrated debugger is not code which I have
written, but it is GDB 4.16, which is linked in RHIDE.
Because RHIDE uses a special method to communicate with GDB it is currently
not possible to use all of the features, which GDB has. I have implemented
at this time the most important functions, which are needed to debug your
program. So it is not possible to give GDB the same commands as when
running GDB stand alone. That means, if you need any very special feature
of GDB you must run GDB.
The integrated debugger is a real source level debugger like GDB. If you
step through your program you will see every time exactly where in the
sources you are. But to use the ability to debug your program needs, that
you have compiled your source files with debugging information and these
symbols must not have been stripped from the executable.
* Menu:
* Limitations of the integrated debugger::
* Dual display debugging::
* Using the integrated debugger::
* Problems with C++ programs::
* Using Breakpoints::
File: rhide.inf, Node: Limitations of the integrated debugger, Next: Dual display debugging, Prev: Debugging with RHIDE, Up: Debugging with RHIDE
5.1 Limitations of the integrated debugger
==========================================
Because the integrated debugger is GDB, you will have all the limitations
which GDB has in addition to well known DJGPP and/or MS-DOS limitations.
Here is a (not complete) list of known misfeatures:
* Signals are not correctly handled every time by distinguishing between
the debuggee and RHIDE
* Remote debugging is NOT supported
* Debugging of graphic programs may work or not depending on the
software you are using. Currently only the VESA modes and the
standard VGA graphic modes are supported.
* When using the integrated debugger under Windows 3.1x (in Windows 95
there is no such limitation) the number of breakpoints is limited to
3, because you can use there only hardware breakpoints. The i386
supports only 4 hardware breakpoints and 1 is needed for internal use.
This is a common problem for all DJGPP debuggers. (Try to use FSDB
with more than 3 breakpoints under Windows 3.1x)
* Sometimes the source line, which is shown by RHIDE in assuming that
the execution is there, is not correct. But this is NOT a bug of
RHIDE and NOT of GDB. This is a bug in GCC which produces wrong line
number information in the object files. Here is a very simple test
program, with which you can see this problem.
/* This is an example, that GCC produces wrong line number
information for code which is optimized out. (compile this
with -O) */
int a = 1;
int b = 2;
int main()
{
if (a == b) return 0;
if ((a + 1) == b) return 1;
return 0; /* The debugger should never come here,
but it comes */
}
File: rhide.inf, Node: Dual display debugging, Next: Using the integrated debugger, Prev: Limitations of the integrated debugger, Up: Debugging with RHIDE
5.2 Dual display debugging
==========================
RHIDE supports now also to use an installed dual display. This is when you
have installed in addition to your VGA card a monochrome display card
together with a monitor. RHIDE checks this by asking the BIOS if it is
present and if this is true and the option is enabled (*Note
Preferences::) then RHIDE switches automatically to the secondary display
when debugging and your program will run on the primary display.
With this debugging technique you will get the best debugging results
especially when debugging graphics programs.
To use the dual display with RHGDB use the `-D' switch for RHGDB.
File: rhide.inf, Node: Using the integrated debugger, Next: Problems with C++ programs, Prev: Dual display debugging, Up: Debugging with RHIDE
5.3 Using the integrated debugger
=================================
If you are familiar with Borland's debugger, you will see, that most of
the functions of that debugger are implemented in the same or in a similar
way (this includes the key bindings).
* Menu:
* Stepping through the source code::
* Evaluating the contents of variables::
* Watching the contents of variables::
File: rhide.inf, Node: Stepping through the source code, Next: Evaluating the contents of variables, Prev: Using the integrated debugger, Up: Using the integrated debugger
5.3.1 Stepping through the source code
--------------------------------------
For stepping through your code, there are three ways. This is at first the
Step-function <F8>. With this you execute a complete source line. If there
is a function call at the current execution point, this function is called
without debugging it. This technique is the same like the `next'-command
from GDB.
The next way is the Trace-function. It is like the Step-function, <F7>,
except that if there is a function call at the current execution point,
you will go into this function when there is debugging information for
that function available. This technique is the same as the `step'-command
from GDB.
And the third way is the Goto-Cursor-function. For this, move the cursor
to the line in your source code and press <F4>. Now the execution of your
program is continued until it comes to that line. Sometimes you will get
an error message, that for the specified line is no code generated. This
comes from the optimization of your code by GCC. In this case try a line
below or above.
File: rhide.inf, Node: Evaluating the contents of variables, Next: Watching the contents of variables, Prev: Stepping through the source code, Up: Using the integrated debugger
5.3.2 Evaluating the contents of variables
------------------------------------------
You can evaluate also the the contents of variables, when your program has
been started. For this you can press `Ctrl+F4' and you will see a dialog,
where you can type in the expression to evaluate, a line with the result
and a line, where you can give the expression a new value. If you have
pressed this in an editor window, RHIDE tries to find the word under the
cursor and copies this as default in the expression input line. To get the
contents of this expression you have to press the *Evaluate*-button.
If the expression could not be evaluated so it is shown in the result line.
For the exact syntax of getting the contents of an expression see *Note
Expressions: (gdb)Expressions. You can also show the value of the
expression in several formats, see *Note Output Formats: (gdb)Output
Formats.
In addition to the functionality of the Borland debuggers, GDB (and of
course also RHIDE) can evaluate the result of function calls. If you have,
for example, in your debugged program a function
int foo(int arg1)
{
/* do something and return a value */
}
defined, you can type in the expression input line
foo(16)
and you will get as result, what the function would return, if it is
called with the argument `16'. As arguments you can also use any known
variable or complex expressions.
A known limitation is, that the expressions are NOT checked for validity.
That means, you can produce any exception there, which will terminate your
program. As an example type in the expression input line
3/0
And, of course, you cannot assign to a function call a new value.
As an special side effect you can use this also as a calculator. You can
evaluate any trivial or complex expression and this is also available, if
you haven't started the integrated debugger.
File: rhide.inf, Node: Watching the contents of variables, Prev: Evaluating the contents of variables, Up: Using the integrated debugger
5.3.3 Watching the contents of variables
----------------------------------------
In addition to a single look at the contents of a variable, you can add
the variable to a list which is updated after each debugger step and is
shown in the watching window. For this function you can use the hotkey
`Ctrl+F7'.
Within the watch window you can press <Enter> on an expression to change
that expression (NOT the contents of that expression) or you can press
<Del> to remove the variable from the watch window.
File: rhide.inf, Node: Problems with C++ programs, Next: Using Breakpoints, Prev: Using the integrated debugger, Up: Debugging with RHIDE
5.4 Problems with C++ programs
==============================
Because GDB cannot handle correctly C++ debugging information when it is
generated as COFF debugging information (with stabs debugging information
there is no such limitation and you can skip reading more) you will have
many problems when debugging C++ programs to get the contents of a
variable when it is a member of a class. Because GDB does not detect, that
your program is a C++ program, it sees it as a normal C program and so GDB
does nothing know about classes and all what have to do with it.
For accessing the member of a baseclass you must do some tricks. Let me
explain it on an example:
class A
{
public:
int a;
};
class B : public A
{
public:
void test();
};
void B::test()
{
fprintf(stdout,"%d\n",a);
}
If you debug the program in the function `B::test()' and you want to get
the contents of the member `a', you have to access it with `this->A.a' !!!
That means: At first you must access all members with the implicit `this'
variable and at second you must give all baseclasses until that, where the
member was declared.
File: rhide.inf, Node: Using Breakpoints, Prev: Problems with C++ programs, Up: Debugging with RHIDE
5.5 Using Breakpoints
=====================
Breakpoints are a very useful thing when debugging a program. You can set
a breakpoint at any location of your program and run it. It will be
automatically stopped, if the program execution reaches the breakpoint.
* Menu:
* Setting a breakpoint::
* Modifying and setting a breakpoint::
* Problems with breakpoints::
File: rhide.inf, Node: Setting a breakpoint, Next: Modifying and setting a breakpoint, Prev: Using Breakpoints, Up: Using Breakpoints
5.5.1 Setting a breakpoint
--------------------------
For setting a breakpoint there are two different ways. The first is by
setting a breakpoint at any line by pressing `Ctrl+F8'. You will see, that
there is a breakpoint set, that this line is shown in another color. If
you hit `Ctrl+F8' on a line, which has already a breakpoint, the
breakpoint at this line is removed.
File: rhide.inf, Node: Modifying and setting a breakpoint, Next: Problems with breakpoints, Prev: Setting a breakpoint, Up: Using Breakpoints
5.5.2 Modifying and setting a breakpoint
----------------------------------------
The second way is by setting a breakpoint with the breakpoint dialog which
is selectable only from the menu. There you will see any breakpoint for
your program. These breakpoints can be modified now in many things. In
this dialog you can enable/disable a breakpoint. This is not the same as
deleting and resetting it. If you disable a breakpoint, it is stored
internally but it is not used. If you enable it again all the settings for
that breakpoint, which you have already made, are remembered.
In the breakpoint dialog you can also set or delete a breakpoint with the
given buttons. If you want to set a new breakpoint, use the New-Button.
Then you will get a dialog which you also get when you press the
Modify-Button. In this dialog you can change many things of the breakpoint.
In this dialog is the only point for setting a breakpoint at a specified
function. For doing this you must set at first the type of the breakpoint
to Function. Then you can type in the function input line the name of the
function or hit <Ctrl+F1> to get a list of functions which are available
from where you can select one with <Enter>.
For setting a breakpoint at a specified line, set the breakpoint type to
Line and type in the filename and the linenumber.
The next what you can modify on a breakpoint is a condition. That means
that the breakpoint should stop your program only, if the condition is
true. Write the condition in the programming language of your source file
and you can use any accessible variable and you can call also functions of
the debugged program. For other information about the syntax see *Note
Conditions: (gdb)Conditions.
And at last you can give your breakpoints also a count. A breakpoint count
is a number, how often this breakpoint is ignored. That means, if you type
there, for example, `10', then the RHIDE stops the execution of the program
only, if it comes to that point the tenth time. WARNING: This count is set
by RHIDE only once. After the breakpoint is really hit, from now on the
breakpoint stops your program every time, the breakpoint is reached.
File: rhide.inf, Node: Problems with breakpoints, Prev: Modifying and setting a breakpoint, Up: Using Breakpoints
5.5.3 Problems with breakpoints
-------------------------------
Currently there is a big problem, when you have set a breakpoint at a line
(not at a function) of your program and you edit now the source code. If
you insert or delete some lines the breakpoints, which are set at lines
after or at the modified lines are NOT updated to the correct line number.
File: rhide.inf, Node: Debugging with RHGDB, Next: Some FAQs, Prev: Debugging with RHIDE, Up: Top
6. Debugging with RHGDB
***********************
In addition to RHIDE, which has an integrated debugger, there is also a
stand-alone debugger called RHGDB. (The name comes from my initials and
GDB)
RHGDB has the same abilities as RHIDE for debugging your program. But it
has no editor. The source files are shown in read only windows where you
can move the cursor and other things (except editing) like in RHIDE.
The menu tree is analog of RHIDE's but (of course) it has not all the menu
entries of RHIDE, because RHGDB should be used only for debugging and
nothing else.
I have written it to debug DJGPP programs, for which there is no RHIDE
project file available but the program has debugging information and, if
you are short of memory, it is much smaller than RHIDE.
The syntax for using RHGDB is very simple. Run it with your program as the
first argument followed by any argument, which should be passed to your
program.
RHGDB saves and reads the options from files with the suffix `.rgd'. This
is done automatically when you run RHGDB with your program as argument by
searching a file with the same basename of your program and the suffix
`.rgd' and in this file the options are also automatically stored, when
you exit RHGDB.
Alternatively you can also save/read the options from within RHIDE by
selecting the corresponding menu entries from the Options menu.
To use the the "Dual display debugging" feature of RHGDB you must give on
commandline the `-D' switch.
File: rhide.inf, Node: Some FAQs, Next: Index, Prev: Debugging with RHGDB, Up: Top
7. Some FAQs
************
**Question*: I have enabled the `Use tabs' option, but if I move the
cursor through that tab, it seems, that RHIDE uses spaces*
*Answer*:This behavior cannot (currently) be changed. Even when you have
enabled the use of real tabs (characters with the code 9), the cursor is
moved as if there are spaces.
**Question*: Are there any sample project files, to show how RHIDE works?*
*Answer*:The sources of RHIDE include many project files to rebuild at
least RHIDE with itself and many others.
**Question*: I have written some libraries. How can I use them in a
project?*
**Question*: How I can use a library, which I have?*
*Answer*: There are some different ways to do this. On the one side you can
include them directly in the project with the *Add to project item*
function (*Note Add item::). But if they are not in the current directory,
you must also set the library search path to the directory, where they
are. (*Note Library directories::). The other variant is to include them
in the list of libraries. (*Note Libraries::)
If this library is created with RHIDE, that means you have a project file
for building this library you can also simply include that project file in
your project. For examples, look at the RHIDE sources in the project file
for RHIDE.
**Question*: I have a directory, where all my include files are. Can I
setup RHIDE to have this directory every time in the include search path,
when creating a new project?*
**Question*: I prefer the 80x28 video mode over the default 80x25 mode.
How I can turn this mode on by default for all newly created project
files?*
*Answer*: You can create a default project file. From this file RHIDE reads
all the options, if it creates a new project. The default project must
have the same basename as the executable of RHIDE and must be located in
the same directory.
The creation of such a default project file is very simple. Change to the
directory, where `rhide.exe' is located and run there
rhide rhide
Now make any changes in the options which you want to have as default for
all newly created projects. This includes also settings in the various
search paths. If you are ready, exit RHIDE and this project file will be
your default project file.
**Question*: I know, that I can create a default project file. Can I
create and use more than one?*
*Answer*:Since DJGPP supports a quasi-Unix-like link for executables, you
can create such a link also for RHIDE. As an example I will create a link
to `rhide.exe' with the name `myrhide.exe'. At first I have to create the
new file.
stubify -g myrhide.exe
Now I must tell `myrhide.exe' which program it really should run.
stubedit myrhide.exe runfile=rhide
Thats all. Or, if you have installed the GNU fileutils, you can use also
now the `ln.exe' program to create the link:
ln -s rhide.exe myrhide.exe
**Question*: I don't want to type every time I start RHIDE the commandline
-L DE to use the German user interface. Is there any better way?*
*Answer*: Create an environment variable LANGUAGE with your preferred
language like
set LANGUAGE=de
and your problem is solved.
**Question*: I have 4 Mb RAM in my computer and every time, when I compile
large files with optimizations enabled, my hard disk is working very hard.*
*Answer*:Buy more RAM!
**Question*: I heard something about a newer version RHIDE. From where I
can get exact information about this?*
*Answer*: See at the RHIDE home page, at this URL:
http://www.tu-chemnitz.de/~rho/rhide.html
. (valid until at least 30. Sepetember 1997) This page contains the
latest news and the latest version of RHIDE.
**Question*: I have a lot of money and don't know what to do with it. Can
you help me?*
*Answer*: Send it to me, so I can spend more time for developing RHIDE. My
Address is:
Robert Höhne
Am Berg 3
D-09573 Dittmannsdorf
Germany
**Question*: I think, I found a bug in RHIDE. How can I report it?*
*Answer*:At first try for your own to solve the problem by checking the
documentation.
If the bug is releated to the editor (some keys do not work, autoindenting
is not like you expect, program creash after some special editing ....)
please send them to SALVADOR EDUARDO TROPEA (SET) <ice@inti.edu.ar>,
because he is the author of the in RHIDE integrated editor.
See at the RHIDE home page, at this URL:
http://www.tu-chemnitz.de/~rho/rhide.html
(valid until at least 30. September 1997), if this problem was already
reported by other users. As the next ask the problem in the news group
comp.os.msdos.djgpp Newsgroup, because there may be some other people with
the same problem, and they can give you an answer or I, because I read
this group also.
Linux users should post thier problems in the linux group. To make sure
that I will read it there also, please include in the subject anywhere the
word RHIDE so I will find it, because I do not read any article there
because the group is too heavily used. Currently I do only a subject
search for the word RHIDE and if not found I mark the group as readed by
me. Sorry for this, but compared with the very good comp.os.msdos.djgpp
group the linux groups are too large for seriously diskussion (at least
for me).
If this don't help you, do the following:
Try to reproduce the error with the smallest possible project or
source file. Run RHIDE with all debugging options enabled and redirect
the printed output to a file. (*Note Debugging RHIDE::) Send me this
file and a detailed as possible description of the problem and
include in your report the exact version of RHIDE you are using.
The exact version is shown in the About-Dialog and means the version
number together with the build date.
And a last note. If I get bug reports or questions or problems with RHIDE
which I think that they are of common interest be warned that I bounce
them simply to the news groups because at this time it is impossible for
me to answer all the mails I get. So the best is to post the questions
and/or problems only in the news groups.
File: rhide.inf, Node: Index, Next: Index of key commands, Prev: Some FAQs, Up: Top
8. Index
********
* Menu:
* Adding a file to the project: Add item.
* Additional options for GCC: Compiler options.
* Arguments for your program: Arguments.
* Assembler files, which must be preprocessed: Known suffixes.
* Automatic dependencies: Standard headers.
* Automatic dependencies, problems with it: Problems with automatic dependencies.
* Automatic indention: autoindent.
* Automatic intention: Intelligent C indenting.
* Background colors, 16: 16 background colors.
* Backup files: create backup files.
* Blinking colors: 16 background colors.
* block commands: Block commands.
* Bug report: Bug report.
* Bug, reporting it: Some FAQs.
* Build: Build all.
* Build the library: Link.
* Building a library: Main targetname.
* Building an executable: Main targetname.
* Builtin calculator: Evaluating the contents of variables.
* Button: How the dialogs work.
* C Flags, edit them: C-Flags.
* C language specific flags: C options.
* C++ flags, edit them: CXX-Flags.
* Caching of files: No file caching.
* Calculator: Calculator.
* Call stack: Call stack.
* Cascade the windows: Cascade.
* Changing the name of the library: Main targetname.
* Changing the name of the program: Main targetname.
* Changing the search paths for files: Directories.
* Checkbox: How the dialogs work.
* Checking dependencies: Checking the dependencies.
* Clear: Clear.
* Clearing the dependencies: Clear dependencies.
* Clearing the project: Delete rebuildable files.
* Clipboard: Show Clipboard.
* Close a project: Close project.
* Close a window: Close.
* COFF file, Creating: Main targetname.
* Colors: Colors.
* Column cursor: Column cursor.
* Commandline arguments for your program: Arguments.
* Commandline options: Getting started.
* Compile: Compile.
* Compile without a project: Some hints and problems.
* Compiler options: Compiler options.
* COMSPEC: DOS Shell.
* Configuring RHIDE <1>: Change the defaults of RHIDE.
* Configuring RHIDE: Configuring RHIDE.
* Context help: The INFO Viewer.
* Controlling the optimization of the code: Optimizations.
* Controlling the warnings: Warnings.
* Copy: Copy.
* Copy to Windows clipboard: Copy to Windows clipboard.
* Cplusplus options: CXX options.
* Creating a COFF file: Main targetname.
* Creating a makefile <1>: Write Makefile.
* Creating a makefile <2>: all dependencies in makefile.
* Creating a makefile: The program GPR2MAK.EXE.
* Creating a new file: New.
* Creating a new project: Open project.
* Creating backup files: create backup files.
* Cross cursor <1>: Column cursor.
* Cross cursor: Row cursor.
* Cursor moving: Cursor moving commands.
* Cursor through tabs: Some FAQs.
* Cut: Cut.
* CXX options: CXX options.
* Debugging: Debugging RHIDE.
* Debugging info: Debugging.
* Debugging RHIDE <1>: Show GDB commands.
* Debugging RHIDE: show process information.
* Debugging with RHIDE: Debug.
* Debugging, dual display: Use dual display.
* Debugging, edit the flags: Debugging-Flags.
* Default file mask: Open.
* Default language: Some FAQs.
* Default project file: Some FAQs.
* Default project file, more than one: Some FAQs.
* Define your own reserved words: User words.
* Defines: Compiler options.
* Delete a file from the project: Delete item.
* Delete the selected text: Clear.
* Deleting commands: Erasing commands.
* Dependencies for a file: Includes.
* Dependencies in makefile: all dependencies in makefile.
* Dependencies, checking: Checking the dependencies.
* Dependencies, problems with it: Problems with automatic dependencies.
* Dialog function keys: How the dialogs work.
* Different name for RHIDE: Some FAQs.
* Directory for temp files: Running under Windows 95.
* Disable shadows: Use no shadows.
* Disassembler: Disassembler window.
* Donations to the author: Some FAQs.
* DOS: DOS Shell.
* Dual display: Dual display debugging.
* Dual display when debugging: Use dual display.
* Dual display with RHGDB: Debugging with RHGDB.
* Edit a file: Open.
* Edit the list of C flags: C-Flags.
* Edit the list of C++ flags: CXX-Flags.
* Edit the list of debugging flags: Debugging-Flags.
* Edit the list of Fortran flags: Fortran-Flags.
* Edit the list of optimization flags: Optimization-Flags.
* Edit the list of Pascal flags: Pascal-Flags.
* Edit the list of reserved words: Reserved words.
* Edit the list of reserved words for Pascal: Pascal reserved words.
* Edit the list of user defined words: User words.
* Edit the list of warning flags: Warning-Flags.
* Editor: How the editor works.
* Editor options: Editor options.
* Editor, block commands: Block commands.
* Editor, cursor moving: Cursor moving commands.
* Editor, erasing commands: Erasing commands.
* Editor, other useful commands: Other commands.
* Editor, select some text: Text selecting and searching commands.
